#include <iostream>
#include <vector>
#include <cstdlib>
#include <signal.h>
#include <math.h>
#include <set>
#include <sstream>
#include <string>
#include <cstdio>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <algorithm>


using namespace std;

typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector< vector<pair<float,float> > > vvpun;

typedef struct _jugada {
	float puntaje_propio;
	int i;
	int j;
	int d;
} jugada;

void setear_jugada(jugada &jug, float puntaje, int i, int j, int d) {
	jug.puntaje_propio = puntaje;
	jug.i = i;
	jug.j = j;
	jug.d = d;
}

#define forn(i,n) for(int i=0; i < (int)(n); ++i)
#define MAS_INFINITO 999999
#define MENOS_INFINITO -999999

vvint tbl;
vvpun tbl_puntajes;
vvint tbl_islas;

int n;
int yo;
int isla_actual = 2;

float cantidad_islas_propias;
float cantidad_islas_enemigas;
float tamanio_islas_propias;
float tamanio_islas_enemigas;
float factor_expansion_propio;
float factor_expansion_enemigo;
int parametro_profundidad;

/* Función para mostrar el tablero en stderr */
void board_show() {
	forn(i,n) { forn(j,n) cerr << ".#X"[tbl[i][j]+1]; cerr << endl; }
}

int ValorIsla(vvint &tbl, int n, int i, int j, int c) {/*int numeroIsla*/
	int res = 0;
	
	if((i>-1)
		&& (j>-1)
		&& (i<n)
		&& (j<n)
		&& (tbl[i][j] == c)) {
		tbl[i][j] = -1;
		res = 1;
		res = res + ValorIsla(tbl,n,i+1,j,c);
		res = res + ValorIsla(tbl,n,i,j+1,c);
		res = res + ValorIsla(tbl,n,i-1,j,c);
		res = res + ValorIsla(tbl,n,i,j-1,c);
	}
	
	return res;
}

int dameIslaPropia(int i, int j, int d, int k) {
	if(i>0) {
		if(tbl[i-1][j] == k) {
			return tbl_islas[i-1][j];
		}
		if( d == 0 && tbl[i-1][j+1] == k) {
			return tbl_islas[i-1][j+1];
		}
	}
	if(j>0) {
		if(tbl[i][j-1] == k) {
			return tbl_islas[i][j-1];
		}
		if(d == 1 && tbl[i+1][j-1] == k) {
			return tbl_islas[i+1][j-1];
		}
	}
	if(d == 0) {
		if(j<n-2 && tbl[i][j+2] == k ) {
			return tbl_islas[i][j+2];
		}
		if(i<n-1 && tbl[i+1][j] == k ) {
			return tbl_islas[i+1][j];
		}
	}
	if(d == 1) {
		if(i<n-2 && tbl[i+2][j] == k ) {
			return tbl_islas[i+2][j];
		}
		if(j<n-1 && tbl[i][j+1] == k ) {
			return tbl_islas[i][j+1];
		}
	}
	if(i<n-1 && j<n-1) {
		if(tbl[i+1][j+1] == k ) {
			return tbl_islas[i+1][j+1] ;
		}
	}
	return -1;
}

void pintar(int i, int j, int c , int color) {
	if( (i>-1)
		&& (j>-1)
		&& (i<n)
		&& (j<n)
		&& (tbl[i][j] == c)
		&& (tbl_islas[i][j] != color)) {
		
		tbl_islas[i][j] = color;
		pintar(i+1,j,c,color);
		pintar(i,j+1,c,color);
		pintar(i-1,j,c,color);
		pintar(i,j-1,c,color);
	}
}

int nuevaIsla() {
	isla_actual = isla_actual + 2;
	return isla_actual;
}

void aplica_movida(int i, int j, int d, int k) {
	int isla = -1;
	tbl[i][j] = k;
	tbl[i+d][j+1-d] = k;
	
	isla = dameIslaPropia(i, j, d, k);
	if (isla != -1) {
		pintar(i,j,k,isla);
	} else {
		pintar(i,j,k,nuevaIsla()+k);
	}
}

void lee_movida(int k) {
	int i,j,d;
	cin >> i >> j >> d; i--; j--;
	/* No es necesario checkear que la jugada sea válida, estamos seguros */
	aplica_movida(i,j,d,k);
}

int hay_movida() {
	forn(i,n) forn(j,n-1) if (tbl[i][j] == -1 && tbl[i][j+1] == -1) return true;
	forn(i,n-1) forn(j,n) if (tbl[i][j] == -1 && tbl[i+1][j] == -1) return true;
	return false;
}

/* Cuando se reciba un SIGTERM se ejecutará esta función. No es necesario
 * hacer nada acá, pero si alguno lo necesita puede hacer alguna tarea acá,
 * como guardar estadísticas del juego, etc. */
void terminar(int) {
	cerr << "Uy!, se acabó el partido!" << endl;
	exit(0);
}

void pinto_tablero_auxiliar_de_blancos (vvint &tablero,int i, int j,int d,int color) {
	if (i>0) {
		if (d ==0) {
			// son las 2 celdas que estan arriba
			if(tbl_islas[i-1][j] == -1) tablero[i-1][j] = color;
			if(tbl_islas[i-1][j+1] == -1) tablero[i-1][j+1] = color;
		} else {
			// es la celda que esta arriba
			if(tbl_islas[i-1][j] == -1) tablero[i-1][j] = color;
		}
	}
	if(i<n-1) {
		if (d ==0) {
			// son las 2 celdas que estan abajo
			if(tbl_islas[i+1][j] == -1) tablero[i+1][j] = color;
			if(tbl_islas[i+1][j+1] == -1) tablero[i+1][j+1] = color;
		} else {
			// es la celda que esta abajo
			if(i<n-2) if(tbl_islas[i+2][j] == -1) tablero[i+2][j] = color;
		}
	}
	if (j>0) {
		if (d ==0) {
			// es la celda que esta a la izquierda
			if(tbl_islas[i][j-1] == -1) tablero[i][j-1] = color;
		} else {
			// son las 2 celdas que estan a la izquierda
			if(tbl_islas[i][j-1] == -1) tablero[i][j-1] = color;
			if(tbl_islas[i+1][j-1] == -1) tablero[i+1][j-1] = color;
		}
	}
	if (j<n-1) {
		if (d ==0) {
			if (j<n-2)if(tbl_islas[i][j+2] == -1) tablero[i][j+2] = color;
		} else {
			// son las 2 celdas que estan a la derecha
			if(tbl_islas[i][j+1] == -1) tablero[i][j+1] = color;
			if(tbl_islas[i+1][j+1] == -1) tablero[i+1][j+1] = color;
		}
	}
}
void pintar(vvint &tablero,vvint &tablero_islas,int i, int j, int c , int color) {
	if( (i>-1)
		&& (j>-1)
		&& (i<n)
		&& (j<n)
		&& (tablero[i][j] == c)
		&& (tablero_islas[i][j] != color)) {

		tablero_islas[i][j] = color;
		pintar(tablero,tablero_islas,i+1,j,c,color);
		pintar(tablero,tablero_islas,i,j+1,c,color);
		pintar(tablero,tablero_islas,i-1,j,c,color);
		pintar(tablero,tablero_islas,i,j-1,c,color);
	}
}

void pinto_tablero_auxiliar_de_blancos (vvint &tablero_jugadas,vvint &tablero,int i, int j,int d,int color) {
	if (i>0) {
		if (d ==0) {
			// son las 2 celdas que estan arriba
			if(tablero_jugadas[i-1][j] == -1) tablero[i-1][j] = color;
			if(tablero_jugadas[i-1][j+1] == -1) tablero[i-1][j+1] = color;
		} else {
			// es la celda que esta arriba
			if(tablero_jugadas[i-1][j] == -1) tablero[i-1][j] = color;
		}
	}
	if(i<n-1) {
		if (d ==0) {
			// son las 2 celdas que estan abajo
			if(tablero_jugadas[i+1][j] == -1) tablero[i+1][j] = color;
			if(tablero_jugadas[i+1][j+1] == -1) tablero[i+1][j+1] = color;
		} else {
			// es la celda que esta abajo
			if(i<n-2) if(tablero_jugadas[i+2][j] == -1) tablero[i+2][j] = color;
		}
	}
	if (j>0) {
		if (d ==0) {
			// es la celda que esta a la izquierda
			if(tablero_jugadas[i][j-1] == -1) tablero[i][j-1] = color;
		} else {
			// son las 2 celdas que estan a la izquierda
			if(tablero_jugadas[i][j-1] == -1) tablero[i][j-1] = color;
			if(tablero_jugadas[i+1][j-1] == -1) tablero[i+1][j-1] = color;
		}
	}
	if (j<n-1) {
		if (d ==0) {
			if (j<n-2)if(tablero_jugadas[i][j+2] == -1) tablero[i][j+2] = color;
		} else {
			// son las 2 celdas que estan a la derecha
			if(tablero_jugadas[i][j+1] == -1) tablero[i][j+1] = color;
			if(tablero_jugadas[i+1][j+1] == -1) tablero[i+1][j+1] = color;
		}
	}
}


float puntuador_tableros(vvint tablero) {
	int contador_islas_propias =0;
	int contador_islas_enemigas=0;
	vvint tbl_islas_punt = vvint(n, vint(n, -1));
	vvint tablero_pintado(tablero);
	int islita = 2;
	int posicion;
	forn(i,n) forn(j,n) {
		posicion = tablero[i][j];
		if (posicion == yo && tbl_islas_punt[i][j] == -1){
			contador_islas_propias++;
		}
		if (posicion == (1-yo) && tbl_islas_punt[i][j] == -1){
			contador_islas_enemigas++;
		}
		if ((posicion == 0 || posicion == 1) && tbl_islas_punt[i][j] == -1){
			pintar(tablero,tbl_islas_punt,i,j,posicion,(islita+=2)+posicion);
		}
	}
	
	float puntaje_expansion_propio = 0;
	float puntaje_expansion_enemigo = 0;
	float puntaje_propio = 0;
	float puntaje_contrincante = 0;
	float res = 0;
	
	forn(i,n) forn(j,n) {
		puntaje_propio = puntaje_propio + pow(ValorIsla(tablero_pintado,n,i,j,yo),2);
		puntaje_contrincante = puntaje_contrincante + pow(ValorIsla(tablero_pintado,n,i,j,1-yo),2);


	}
	
	vvint tablero_espacios_blancos_mios;
	vvint tablero_espacios_blancos_contrincante;
	tablero_espacios_blancos_mios = vvint(n, vint(n, -1));
	tablero_espacios_blancos_contrincante = vvint(n, vint(n, -1));
	
	forn(i,n) forn(j,n) {
		if ((j<n-1) && tablero[i][j] == yo && tablero[i][j+1] == yo) {
			pinto_tablero_auxiliar_de_blancos(tablero,tablero_espacios_blancos_mios,i,j,0,yo);
		}
		if ((i<n-1) && tablero[i][j] == yo && tablero[i+1][j] == yo) {
			pinto_tablero_auxiliar_de_blancos(tablero,tablero_espacios_blancos_mios,i,j,1,yo);
		}
		if ((j<n-1) && tablero[i][j] == (1-yo) && tablero[i][j+1] == (1-yo)) {
			pinto_tablero_auxiliar_de_blancos(tablero,tablero_espacios_blancos_contrincante,i,j,0,(1-yo));
		}
		if ((i<n-1) && tablero[i][j] == (1-yo) && tablero[i+1][j] == (1-yo)) {
			pinto_tablero_auxiliar_de_blancos(tablero,tablero_espacios_blancos_contrincante,i,j,1,(1-yo));
		}
	}

	forn(i,n)forn(j,n){
		if(tablero_espacios_blancos_mios[i][j] == yo)
			puntaje_expansion_propio++;  
		if(tablero_espacios_blancos_contrincante[i][j] == (1-yo))
			puntaje_expansion_enemigo++;  
	}	

	res = 	puntaje_propio * tamanio_islas_propias +
			puntaje_contrincante * tamanio_islas_enemigas +
			contador_islas_propias * cantidad_islas_propias +
			contador_islas_enemigas *  cantidad_islas_enemigas +
			puntaje_expansion_propio * factor_expansion_propio +
			puntaje_expansion_enemigo * factor_expansion_enemigo;

	return res;
}

jugada obtener_jugada(vvint &jugadas, int n, int k, float alfa, float beta, int profundidad) {
	jugada res;
	jugada actual;
	int modif;
	float puntaje = MAS_INFINITO;
	bool jugue = false;
	
	setear_jugada(res,0,-1,-1,-1);
	
	if (yo == k) { //juego yo
		modif  = 1;
	} else { //juega el otro
		modif = -1;
	}
	
	profundidad ++;
	
	puntaje  = puntaje * modif*(-1);
	
	if (profundidad <= parametro_profundidad ) {
		for (int i =0; i < n;i++) {
			for (int j =0; j < n;j++) {
				if ((j<n-1) && jugadas[i][j] == -1 && jugadas[i][j+1] == -1) {
					jugadas[i][j] = k;
					jugadas[i][j+1] = k;
					jugue = true;
					actual = obtener_jugada( jugadas, n, 1-k,alfa,beta,profundidad);
					if(actual.puntaje_propio*modif > puntaje*modif) {
						puntaje = actual.puntaje_propio;
						setear_jugada(res,res.puntaje_propio,i,j,0);
					}
					jugadas[i][j] = -1;
					jugadas[i][j+1] = -1;
					
					if(modif == 1) {
						if(alfa < puntaje) alfa = puntaje;
						if (beta < puntaje) return actual;
					} else {
						if(beta > puntaje) beta = puntaje;
						if (alfa > puntaje) return actual;
					}
				}
				
				if ((i<n-1) && jugadas[i][j] == -1 && jugadas[i+1][j] == -1) {
					jugadas[i][j] = k;
					jugadas[i+1][j] = k;
					jugue = true;
					actual = obtener_jugada( jugadas, n, 1-k,alfa,beta,profundidad);
					if(actual.puntaje_propio*modif > puntaje*modif) {
						puntaje = actual.puntaje_propio;
						setear_jugada(res,res.puntaje_propio,i,j,1);
					}
					jugadas[i][j] = -1;
					jugadas[i+1][j] = -1;
					
					if(modif == 1) {
						if(alfa < puntaje) alfa = puntaje;
						if (beta < puntaje) return actual;
					} else {
						if(beta > puntaje) beta = puntaje;
						if (alfa > puntaje) return actual;
					}
				}
			}
		}
	}
	
	if(!jugue){
		res.puntaje_propio = puntuador_tableros(jugadas);
	} else {
		res.puntaje_propio = puntaje;
	}
	
	return res;
}

void juega_movida(int k) {
	int a =  MENOS_INFINITO;
	int b =  MAS_INFINITO;
	jugada res = obtener_jugada(tbl,n,k,a,b,0);
	
	aplica_movida(res.i,res.j,res.d,k);
	
	cout << res.i+1 << " " << res.j+1 << " " << res.d << endl;
}

string chartostring(char * ptr_char) {
	stringstream ss;
	string s;
	ss << ptr_char;
	ss >> s;
	return s;
}

int main(int argc, char* argv[]) {
	signal(SIGTERM, terminar);
	cin >> n >> yo;
	
	// Levanto los parametros que me pasaron.
	int cant_param = argc;
	cant_param--;
	while (cant_param){
		string param = chartostring(argv[cant_param]);
		if (param.substr(0,6)=="-p_cip") cantidad_islas_propias = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_cie") cantidad_islas_enemigas = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_tip") tamanio_islas_propias = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_tie") tamanio_islas_enemigas = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_fep") factor_expansion_propio = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_fee") factor_expansion_enemigo = atof(argv[cant_param]+7);
		if (param.substr(0,6)=="-p_pro") parametro_profundidad = atoi(argv[cant_param]+7);
		cant_param--;
	}
	
	tbl = vvint(n, vint(n, -1));
	tbl_islas = vvint(n, vint(n, -1));
	tbl_puntajes = vector< vector <pair <float, float> > >(n,vector <pair <float, float> >(n,make_pair(0,0)));
	
	/* Si yo==1, arrancamos leyendo una jugada del otro */
	if (n>1 && yo) lee_movida(!yo);
	
	while (hay_movida()) {
		juega_movida(yo);
		
		// Si no hay movida para hacer se cuelga leyendo, pero el judge nos mata el proceso con SIGTERM
		lee_movida(!yo); 
	}
	return 0;
}
